package com.itx.gatewayx.controller;

import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.itx.gatewayx.common.R;
import com.itx.gatewayx.domain.AIConversation;
import com.itx.gatewayx.domain.AIMessage;
import com.itx.gatewayx.domain.AIModel;
import com.itx.gatewayx.domain.dto.AIChatRequest;
import com.itx.gatewayx.domain.dto.AIChatResponse;
import com.itx.gatewayx.service.AIService;
import com.itx.gatewayx.utils.UserUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;

import java.util.List;

/**
 * AI对话控制器
 */
@Slf4j
@RestController
@RequestMapping("/api/ai")
public class AIController {

    @Autowired
    private AIService aiService;
    
    /**
     * 发送AI对话消息
     *
     * @param request 对话请求
     * @return AI回复
     */
    @PostMapping("/chat")
    public R<AIChatResponse> chat(@RequestBody @Validated AIChatRequest request) {
        try {
            // 获取当前用户ID，未登录用户为null
            Long userId = UserUtils.getCurrentUserId();
            AIChatResponse response = aiService.sendMessage(userId, request);
            return R.ok(response);
        } catch (Exception e) {
            log.error("AI对话失败", e);
            return R.fail("AI对话失败：" + e.getMessage());
        }
    }
    
    /**
     * 获取用户的对话历史
     *
     * @param page 页码
     * @param pageSize 每页条数
     * @return 对话历史分页
     */
    @GetMapping("/history")
    public R<Page<AIMessage>> getHistory(
            @RequestParam(defaultValue = "1") Integer page,
            @RequestParam(defaultValue = "20") Integer pageSize) {
        try {
            // 获取当前用户ID，需要登录
            Long userId = UserUtils.getCurrentUserId();
            if (userId == null) {
                return R.fail("请先登录");
            }
            
            Page<AIMessage> history = aiService.getConversationHistory(userId, page, pageSize);
            return R.ok(history);
        } catch (Exception e) {
            log.error("获取对话历史失败", e);
            return R.fail("获取对话历史失败：" + e.getMessage());
        }
    }
    
    /**
     * 获取指定会话的消息列表
     *
     * @param conversationId 会话ID
     * @return 消息列表
     */
    @GetMapping("/conversation/{conversationId}")
    public R<List<AIMessage>> getConversationMessages(@PathVariable Long conversationId) {
        try {
            // 获取当前用户ID，需要登录
            Long userId = UserUtils.getCurrentUserId();
            if (userId == null) {
                return R.fail("请先登录");
            }
            
            List<AIMessage> messages = aiService.getMessagesByConversationId(conversationId, userId);
            return R.ok(messages);
        } catch (Exception e) {
            log.error("获取会话消息失败", e);
            return R.fail("获取会话消息失败：" + e.getMessage());
        }
    }
    
    /**
     * 创建新的对话会话
     *
     * @param modelId 模型ID（可选）
     * @return 会话信息
     */
    @PostMapping("/conversation")
    public R<AIConversation> createConversation(@RequestParam(required = false) String modelId) {
        try {
            // 获取当前用户ID，未登录用户为null
            Long userId = UserUtils.getCurrentUserId();
            AIConversation conversation = aiService.createConversation(userId, modelId);
            return R.ok(conversation);
        } catch (Exception e) {
            log.error("创建会话失败", e);
            return R.fail("创建会话失败：" + e.getMessage());
        }
    }
    
    /**
     * 获取所有可用的AI模型
     *
     * @return 模型列表
     */
    @GetMapping("/models")
    public R<List<AIModel>> getModels() {
        try {
            List<AIModel> models = aiService.getAvailableModels();
            return R.ok(models);
        } catch (Exception e) {
            log.error("获取模型列表失败", e);
            return R.fail("获取模型列表失败：" + e.getMessage());
        }
    }
    
    /**
     * 设置用户当前使用的AI模型
     *
     * @param modelId 模型ID
     * @return 设置结果
     */
    @PostMapping("/model")
    public R<Boolean> setModel(@RequestParam String modelId) {
        try {
            // 获取当前用户ID，需要登录
            Long userId = UserUtils.getCurrentUserId();
            if (userId == null) {
                return R.fail("请先登录");
            }
            
            boolean success = aiService.setUserModel(userId, modelId);
            return success ? R.ok(true) : R.fail("设置模型失败，模型不存在或已禁用");
        } catch (Exception e) {
            log.error("设置模型失败", e);
            return R.fail("设置模型失败：" + e.getMessage());
        }
    }
    
    /**
     * 删除指定的消息
     *
     * @param messageId 消息ID
     * @return 删除结果
     */
    @DeleteMapping("/message/{messageId}")
    public R<Boolean> deleteMessage(@PathVariable Long messageId) {
        try {
            // 获取当前用户ID，需要登录
            Long userId = UserUtils.getCurrentUserId();
            if (userId == null) {
                return R.fail("请先登录");
            }
            
            boolean success = aiService.deleteMessage(messageId, userId);
            return success ? R.ok(true) : R.fail("删除消息失败，消息不存在或无权限");
        } catch (Exception e) {
            log.error("删除消息失败", e);
            return R.fail("删除消息失败：" + e.getMessage());
        }
    }
    
    /**
     * 清空用户的所有对话历史
     *
     * @return 清空结果
     */
    @DeleteMapping("/history")
    public R<Boolean> clearHistory() {
        try {
            // 获取当前用户ID，需要登录
            Long userId = UserUtils.getCurrentUserId();
            if (userId == null) {
                return R.fail("请先登录");
            }
            
            boolean success = aiService.clearHistory(userId);
            return success ? R.ok(true) : R.fail("清空历史失败");
        } catch (Exception e) {
            log.error("清空历史失败", e);
            return R.fail("清空历史失败：" + e.getMessage());
        }
    }
} 